package com.fdb.efp.nls.service.impl.dw;

import com.alibaba.fastjson.JSONObject;
import com.fdb.basic.framework.core.constant.MonAlrmLvlEnums.MonAlrmLvlEnum;
import com.fdb.basic.framework.core.util.DateTool;
import com.fdb.basic.framework.core.util.StringUtil;
import com.fdb.efp.nls.common.constant.DataTransferConstant;
import com.fdb.efp.nls.service.facade.dw.BdDataValidationService;
import com.fdb.efp.nls.service.util.DueDataUtil;
import com.fdb.efp.nls.service.facade.*;
import com.fdb.efp.nls.service.vo.*;
import com.fdb.efp.nls.service.facade.BdSxapplyTempService;
import com.fdb.efp.nls.service.facade.BdYxapplyTempService;
import com.fdb.efp.nls.service.vo.BdSxapplyTempVO;
import com.fdb.efp.nls.service.vo.BdYxapplyTempVO;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.util.Date;
import java.util.Map;
import java.util.Objects;

/**
 * 
 * 数据迁移数据校验
 * 
 * @author ludayong
 * @since 2019年5月17日 下午3:14:26
 * @version 1.0
 */
@Service("bdDataValidationService")
public class BdDataValidationServiceImpl implements BdDataValidationService {

	private static Logger logger = LoggerFactory.getLogger(BdDataValidationServiceImpl.class);

	// 百度账务文件解析地址
	@Value("${analysis.baiduTranFilePath}")
	private String baiduTranFilePath;

	// 数据迁移文件名称
	@Value("${analysis.dataTransferFileName}")
	private String dataTransferFileName;

	// 数据迁移文件后缀
	@Value("${analysis.dataTransferFileSuffix}")
	private String dataTransferFileSuffix;

	// 数据迁移ok文件后缀
	@Value("${analysis.dataTransferOkFileSuffix}")
	private String dataTransferOkFileSuffix;

	// 数据迁移文件分割符
	@Value("${analysis.dataTransferFileSeparation}")
	private String dataTransferFileSeparation;

	// 授信申请临时表信息
	@Autowired
	@Qualifier("bdSxapplyTempService")
	private BdSxapplyTempService bdSxapplyTempService;

	// 用信申请临时表信息
	@Autowired
	@Qualifier("bdYxapplyTempService")
	private BdYxapplyTempService bdYxapplyTempService;

	// 贷款放款明细临时信息
	@Autowired
	@Qualifier("dwBaiduOpenTempService")
	private DwBaiduOpenTempService dwBaiduOpenTempService;

	// 借据临时信息
	@Autowired
	@Qualifier("dwBaiduLoanTempService")
	private DwBaiduLoanTempService dwBaiduLoanTempService;

	// 借据分期计划临时信息
	@Autowired
	@Qualifier("dwBaiduRepayPlanTempService")
	private DwBaiduRepayPlanTempService dwBaiduRepayPlanTempService;

	// 每日还款临时信息
	@Autowired
	@Qualifier("dwBaiduRepayTempService")
	private DwBaiduRepayTempService dwBaiduRepayTempService;

	// 每日还款信息明细临时信息
	@Autowired
	@Qualifier("dwBaiduRepayItemTempService")
	private DwBaiduRepayItemTempService dwBaiduRepayItemTempService;

	// 贷款利息汇率临时信息
	@Autowired
	@Qualifier("dwBaiduLoanRateTempService")
	private DwBaiduLoanRateTempService dwBaiduLoanRateTempService;

	// 并账文件信息临时表服务
	@Autowired
	@Qualifier("dwBaiduLedgerTempService")
	private DwBaiduLedgerTempService dwBaiduLedgerTempService;

	// 迁移文件记录异常信息
	@Autowired
	@Qualifier("accoutErroTempService")
	private AccoutErroTempService accoutErroTempService;

	/**
	 * 
	 * 数据内容校验 <br>
	 * 0.1:ludayong:2019年5月16日 上午8:38:00:新增 <br>
	 * 
	 * @author ludayong
	 * @since 2019年5月16日 上午8:38:00
	 * @date 2019年5月16日 上午8:38:00
	 * @version 0.1
	 */
	@Override
	public boolean validContent(String curDate, String tableInfo, String type) throws Exception {
		boolean result = false;
		long startTime = System.currentTimeMillis();
		logger.info(DataTransferConstant.TABLES.get(tableInfo) + "内容校验：["
				+ DateTool.formatDate(new Date(startTime), DateTool.PATTERN_DATETIME) + "]， 处理开始");
		try {
			// 临时表数据量
			int count = getDataCount(tableInfo, DataTransferConstant.TABLES.get(tableInfo));
			logger.info(DataTransferConstant.TABLES.get(tableInfo) + "内容校验-临时表数据量[" + count + "]");
			if (count == 0) {
				return true;
			}
			// 数据迁移文件路径
			String filePath = baiduTranFilePath + tableInfo + type + curDate + dataTransferFileSuffix;
			// 校验迁移文件是否正确
			if (!checkContextFile(filePath, tableInfo)) {
				return result;
			}
			result = true;
		} catch (Exception e) {
			e.printStackTrace();
			String errorMsg = DataTransferConstant.TABLES.get(tableInfo) + "内容校验出错";
			String remark = DataTransferConstant.TABLES.get(tableInfo) + "内容校验出错，错误信息：" + e.getMessage();
			addErrorInfo(DataTransferConstant.TABLES.get(tableInfo), MonAlrmLvlEnum.SERIOUS.getEnname(), errorMsg, remark);
			logger.error(remark);
			throw new Exception(remark);
		}
		long endTime = System.currentTimeMillis();
		logger.info(DataTransferConstant.TABLES.get(tableInfo) + "内容校验：：["
				+ DateTool.formatDate(new Date(endTime), DateTool.PATTERN_DATETIME) + "]， 处理结束");
		logger.info(DataTransferConstant.TABLES.get(tableInfo) + "内容校验：，耗时：[" + (endTime - startTime) / 1000.0 + "]秒，处理结果[" + result + "]");
		return result;
	}

	/**
	 * 
	 * 数量校验 <br>
	 * 0.1:ludayong:2019年5月16日 上午8:38:00:新增 <br>
	 * 
	 * @author ludayong
	 * @since 2019年5月16日 上午8:38:00
	 * @date 2019年5月16日 上午8:38:00
	 * @version 0.1
	 */
	@Override
	public boolean validNum(String curDate, String tableInfo, String type) throws Exception {
		boolean result = false;
		long startTime = System.currentTimeMillis();
		logger.info("数据迁移数据量校验：[" + DateTool.formatDate(new Date(startTime), DateTool.PATTERN_DATETIME) + "]， 处理开始");
		try {
			// 临时表数据量
			int count = getDataCount(tableInfo, DataTransferConstant.TABLES.get(tableInfo));
			// 数据迁移ok文件路径
			String filePath = baiduTranFilePath + tableInfo + type + curDate + dataTransferOkFileSuffix;
			// 数量校验是否正确
			if (!checkOkFile(filePath, count, tableInfo, DataTransferConstant.TABLES.get(tableInfo))) {
				return result;
			}
			result = true;
		} catch (Exception e) {
			e.printStackTrace();
			String errorMsg = DataTransferConstant.TABLES.get(tableInfo) + "数据量校验出错";
			String remark = DataTransferConstant.TABLES.get(tableInfo) + "数据量校验出错，错误信息：" + e.getMessage();
			addErrorInfo(tableInfo, MonAlrmLvlEnum.SERIOUS.getEnname(), errorMsg, remark);
			logger.error(remark);
			throw new Exception(remark);
		}
		long endTime = System.currentTimeMillis();
		logger.info("数据迁移数据量校验：：[" + DateTool.formatDate(new Date(endTime), DateTool.PATTERN_DATETIME) + "]， 处理结束");
		logger.info("数据迁移数据量校验：，耗时：[" + (endTime - startTime) / 1000.0 + "]秒，处理结果[" + result + "]");
		return result;
	}

	/**
	 * 
	 * 获取数据库信息数据量 <br>
	 * 0.1:ludayong:2019年5月18日 下午12:43:09:新增 <br>
	 * 
	 * @author ludayong
	 * @since 2019年5月18日 下午12:43:09
	 * @date 2019年5月18日 下午12:43:09
	 * @version 0.1
	 */
	public int getDataCount(String tableName, String tableDesc) {
		logger.info("获取******[" + tableDesc + "]******数据量结束");
		// 数据数据量
		int count = 0;
		try {
			switch (tableName) {
			case "s048_bd_sxapply":
				// "授信申请信息"
				count = bdSxapplyTempService.queryCount();
				break;
			case "s048_bd_yxapply":
				// "用信申请信息"
				count = bdYxapplyTempService.queryCount();
				break;
			case "s048_dw_baidu_open":
				// "贷款放款明细信息"
				count = dwBaiduOpenTempService.queryCount();
				break;
			case "s048_dw_baidu_loan":
				// "借据信息"
				count = dwBaiduLoanTempService.queryCount();
				break;
			case "s048_dw_baidu_repay_plan":
				// "借据分期计划信息"
				count = dwBaiduRepayPlanTempService.queryCount();
				break;
			case "s048_dw_baidu_repay":
				// "借据还款信息"
				count = dwBaiduRepayTempService.queryCount();
				break;
			case "s048_dw_baidu_repay_item":
				// "借据还款信息明细信息"
				count = dwBaiduRepayItemTempService.queryCount();
				break;
			case "s048_dw_baidu_loan_rate":
				// "贷款利息费率信息"
				count = dwBaiduLoanRateTempService.queryCount();
				break;
			case "s048_dw_baidu_ledger":
				// "并账信息"
				count = dwBaiduLedgerTempService.queryCount();
				break;
			default:

			}
			logger.info(tableDesc + "数据库信息数据量：" + count);
		} catch (Exception e) {
			e.printStackTrace();
			String errorMsg = "获取" + tableDesc + "数据库信息数据量出错";
			String remark = "获取" + tableDesc + "数据库信息数据量出错，错误信息：" + e.getMessage();
			addErrorInfo(tableName, MonAlrmLvlEnum.SERIOUS.getEnname(), errorMsg, remark);
			logger.error(remark);
		}
		logger.info("获取******[" + tableDesc + "]******数据量结束");
		return count;
	}

	/**
	 * 
	 * 校验迁移文件数据量 <br>
	 * 0.1:ludayong:2019年5月17日 下午2:41:24:新增 <br>
	 * 
	 * @author ludayong
	 * @since 2019年5月17日 下午2:41:24
	 * @date 2019年5月17日 下午2:41:24
	 * @version 0.1
	 */
	public boolean checkOkFile(String filePath, int dataNum, String tableName, String tableDesc) {
		logger.info("校验******[" + tableDesc + "]******数据量开始");
		boolean result = false;
		// 文件读取内容
		String context = "";
		// ok文件数据量
		int okNum = 0;
		try {
			// 读取迁移文件首行内容
			context = DueDataUtil.getFirstLineContext(filePath);
			// 读取的文件内容非空
			if (!StringUtil.isNullorBank(context)) {
				// 校验文件记录数
				okNum = Integer.parseInt(context.substring(context.indexOf("=") + 1, context.length()));
				// ok文件数据量
				if (okNum == dataNum) {
					result = true;
					logger.info(tableDesc + "数据量校验通过，" + tableDesc + "，临时表数据量：" + okNum + "，校验文件数据量：" + okNum);
				} else {
					String errorMsg = tableDesc + "数据量校验不通过";
					String remark = tableDesc + "校验不通过，" + tableDesc + "临时表数据量：" + dataNum + "，校验文件数据量：" + okNum;
					addErrorInfo(tableName, MonAlrmLvlEnum.SERIOUS.getEnname(), errorMsg, remark);
					logger.error(remark);
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
			String errorMsg = "读取" + tableDesc + "校验文件出错";
			String remark = "读取" + tableDesc + "校验文件出错，错误信息：" + e.getMessage();
			addErrorInfo(tableName, MonAlrmLvlEnum.SERIOUS.getEnname(), errorMsg, remark);
			logger.error(remark);
		}
		logger.info("校验******[" + tableDesc + "]******数据量结束");
		return result;
	}

	/**
	 * 
	 * 校验迁移文件内容 <br>
	 * 0.1:ludayong:2019年5月17日 下午2:41:24:新增 <br>
	 * 
	 * @author ludayong
	 * @since 2019年5月17日 下午2:41:24
	 * @date 2019年5月17日 下午2:41:24
	 * @version 0.1
	 */
	public boolean checkContextFile(String filePath, String tableInfo) {
		logger.info("校验******[" + tableInfo + "]******迁移文内容开始");
		boolean result = false;
		// 文件读取内容
		String context = "";
		// 迁移数据信息
		Object object = null;
		try {
			// 读取迁移文件首行内容
			context = DueDataUtil.getFirstLineContext(filePath);
			// 读取的文件内容非空
			if (!StringUtil.isNullorBank(context)) {
				// 对文件内容进行分割
				String[] contexts = context.split(dataTransferFileSeparation);
				// 迁移数据信息
				object = getDataTransferInfo(tableInfo, contexts);
				// 用信申请信息
				if (Objects.nonNull(object)) {
					result = checkFileContext(tableInfo, contexts, object);
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
			String errorMsg = DataTransferConstant.TABLES.get(tableInfo) + "内容校验出错";
			String remark = DataTransferConstant.TABLES.get(tableInfo) + "内容校验出错，错误信息：" + e.getMessage();
			addErrorInfo(tableInfo, MonAlrmLvlEnum.SERIOUS.getEnname(), errorMsg, remark);
			logger.error(remark);
		}
		logger.info("校验******[" + tableInfo + "]******迁移文内容结束");
		return result;
	}

	/**
	 * 
	 * 校验迁移文件内容 <br>
	 * 0.1:ludayong:2019年5月17日 下午2:41:24:新增 <br>
	 * 
	 * @author ludayong
	 * @since 2019年5月17日 下午2:41:24
	 * @date 2019年5月17日 下午2:41:24
	 * @version 0.1
	 */
	public boolean checkFileContext(String tableInfo, String[] contexts, Object object) {
		logger.info("校验******[" + tableInfo + "]******文件内容开始");
		boolean result = false;
		try {
			// 获取数据库列信息
			String cols[] = getDataCols(tableInfo, DataTransferConstant.TABLES.get(tableInfo));
			if (object instanceof BdSxapplyTempVO) {
				BdSxapplyTempVO bdSxapplyTempVO = (BdSxapplyTempVO) object;
				// 查询到的信息
				BdSxapplyTempVO queryBdSxapplyTempVO = bdSxapplyTempService.queryByPk(bdSxapplyTempVO);
				// 校验内容
				result = compareToObjectValue(tableInfo, queryBdSxapplyTempVO, cols, contexts);
			} else if (object instanceof BdYxapplyTempVO) {
				BdYxapplyTempVO bdYxapplyTempVO = (BdYxapplyTempVO) object;
				// 查询到的信息
				BdYxapplyTempVO queryBdYxapplyTempVO = bdYxapplyTempService.queryByPk(bdYxapplyTempVO);
				// 校验内容
				result = compareToObjectValue(tableInfo, queryBdYxapplyTempVO, cols, contexts);
			} else if (object instanceof DwBaiduOpenTempVO) {
				DwBaiduOpenTempVO dwBaiduOpenTempVO = (DwBaiduOpenTempVO) object;
				// 查询到的信息
				DwBaiduOpenTempVO queryDwBaiduOpenTempVO = dwBaiduOpenTempService.queryByPk(dwBaiduOpenTempVO);
				// 校验内容
				result = compareToObjectValue(tableInfo, queryDwBaiduOpenTempVO, cols, contexts);
			} else if (object instanceof DwBaiduLoanTempVO) {
				DwBaiduLoanTempVO dwBaiduLoanTempVO = (DwBaiduLoanTempVO) object;
				// 查询到的信息
				DwBaiduLoanTempVO queryDwBaiduLoanTempVO = dwBaiduLoanTempService.queryByPk(dwBaiduLoanTempVO);
				// 校验内容
				result = compareToObjectValue(tableInfo, queryDwBaiduLoanTempVO, cols, contexts);
			} else if (object instanceof DwBaiduRepayPlanTempVO) {
				DwBaiduRepayPlanTempVO bdSxapplyTempVO = (DwBaiduRepayPlanTempVO) object;
				// 查询到的信息
				DwBaiduRepayPlanTempVO queryDwBaiduRepayPlanTempVO = dwBaiduRepayPlanTempService.queryByPk(bdSxapplyTempVO);
				// 校验内容
				result = compareToObjectValue(tableInfo, queryDwBaiduRepayPlanTempVO, cols, contexts);
			} else if (object instanceof DwBaiduRepayTempVO) {
				DwBaiduRepayTempVO dwBaiduRepayTempVO = (DwBaiduRepayTempVO) object;
				// 查询到的信息
				DwBaiduRepayTempVO queryDwBaiduRepayTempVO = dwBaiduRepayTempService.queryByPk(dwBaiduRepayTempVO);
				// 校验内容
				result = compareToObjectValue(tableInfo, queryDwBaiduRepayTempVO, cols, contexts);
			} else if (object instanceof DwBaiduRepayItemTempVO) {
				DwBaiduRepayItemTempVO dwBaiduRepayItemTempVO = (DwBaiduRepayItemTempVO) object;
				// 查询到的信息
				DwBaiduRepayItemTempVO queryDwBaiduRepayItemTempVO = dwBaiduRepayItemTempService.queryByPk(dwBaiduRepayItemTempVO);
				// 校验内容
				result = compareToObjectValue(tableInfo, queryDwBaiduRepayItemTempVO, cols, contexts);
			} else if (object instanceof DwBaiduLoanRateTempVO) {
				DwBaiduLoanRateTempVO dwBaiduLoanRateTempVO = (DwBaiduLoanRateTempVO) object;
				// 查询到的信息
				DwBaiduLoanRateTempVO queryDwBaiduLoanRateTempVO = dwBaiduLoanRateTempService.queryByPk(dwBaiduLoanRateTempVO);
				// 校验内容
				result = compareToObjectValue(tableInfo, queryDwBaiduLoanRateTempVO, cols, contexts);
			} else if (object instanceof DwBaiduLedgerTempVO) {
				DwBaiduLedgerTempVO dwBaiduLedgerTempVO = (DwBaiduLedgerTempVO) object;
				// 查询到的信息
				DwBaiduLedgerTempVO queryDwBaiduLedgerTempVO = dwBaiduLedgerTempService.queryByPk(dwBaiduLedgerTempVO);
				// 校验内容
				result = compareToObjectValue(tableInfo, queryDwBaiduLedgerTempVO, cols, contexts);
			}
		} catch (Exception e) {
			e.printStackTrace();
			String errorMsg = "校验" + DataTransferConstant.TABLES.get(tableInfo) + "文件内容出错";
			String remark = "校验" + DataTransferConstant.TABLES.get(tableInfo) + "文件内容出错，错误信息：" + e.getMessage();
			addErrorInfo(tableInfo, MonAlrmLvlEnum.SERIOUS.getEnname(), errorMsg, remark);
			logger.error(remark);
		}
		logger.info("校验******[" + tableInfo + "]******文件内容结束");
		return result;
	}

	/**
	 * 
	 * 比较两个对象是否相等 <br>
	 * 0.1:ludayong:2019年5月16日 上午9:06:55:新增 <br>
	 * 
	 * @author ludayong
	 * @since 2019年5月16日 上午9:06:55
	 * @date 2019年5月16日 上午9:06:55
	 * @version 0.1
	 */
	private boolean compareToObjectValue(String tableInfo, Object object, String cols[], String[] contexts) {
		logger.info("校验******[" + tableInfo + "]******文件内容详细字段信息开始");
		boolean result = true;
		if (object == null) {
			logger.info("数据库查询：" + DataTransferConstant.TABLES.get(tableInfo) + "为空");
			result = false;
			String errorMsg = "数据库查询：" + DataTransferConstant.TABLES.get(tableInfo) + "为空";
			String remark = "数据库查询：" + DataTransferConstant.TABLES.get(tableInfo) + "为空";
			addErrorInfo(tableInfo, MonAlrmLvlEnum.SERIOUS.getEnname(), errorMsg, remark);
			logger.error(remark);
		}
		try {
			// 获取对象的字段类型返回Map
			Map<String, String> fieldTypeMap = DueDataUtil.getObjectFieldType(object);
			for (int i = 0; i < cols.length; i++) {
				// 已经校验出来不相等或者文件内容已经读取完时退出
				if (!result || i >= contexts.length) {
					break;
				}
				// 通过反射得到对应的方法
				Method m = (Method) object.getClass().getMethod("get" + cols[i]);
				// 类型为：java.lang.String
				if ("java.lang.String".equals(fieldTypeMap.get(cols[i]))) {
					// 值为：java.lang.String
					String val = (String) m.invoke(object);
					if (val == null || "".equals(val)) {
						if (!(null == contexts[i] || "".equals(contexts[i]))) {
							result = false;
						}
					} else if (!val.equals(contexts[i])) {
						result = false;
					}
					// 打印比较结果信息
					showCompareResultInfo(tableInfo, fieldTypeMap.get(cols[i]), cols[i], val, contexts[i], result);
					// logger.info(
					// "字段类型Type：[" + fieldTypeMap.get(cols[i]) + "]******，字段名称Name：[" + cols[i] +
					// "]，数据库字段值******Value：["
					// + val + "]，迁移文件字段值******Value：[" + contexts[i] + "]******，比较结果[" + result +
					// "]");
				} else if ("java.math.BigDecimal".equals(fieldTypeMap.get(cols[i]))) {
					// 类型为：java.math.BigDecimal
					BigDecimal val = (BigDecimal) m.invoke(object);
					if (val == null) {
						if (!(null == contexts[i] || "".equals(contexts[i]))) {
							result = false;
						}
					} else if ("".equals(contexts[i])) {
						result = false;
					} else if (val.compareTo(new BigDecimal(contexts[i])) != 0) {
						result = false;
					}
					// 打印比较结果信息
					showCompareResultInfo(tableInfo, fieldTypeMap.get(cols[i]), cols[i], val, contexts[i], result);
				} else if ("java.lang.Integer".equals(fieldTypeMap.get(cols[i]))) {
					// 类型为：java.lang.Integer
					Integer val = (Integer) m.invoke(object);
					if (val == null) {
						if (!(null == contexts[i] || "".equals(contexts[i]))) {
							result = false;
						}
					} else if ("".equals(contexts[i])) {
						result = false;
					} else if (val != Integer.parseInt(contexts[i])) {
						result = false;
					}
					// 打印比较结果信息
					showCompareResultInfo(tableInfo, fieldTypeMap.get(cols[i]), cols[i], val, contexts[i], result);
				} else if ("java.lang.Double".equals(fieldTypeMap.get(cols[i]))) {
					// 类型为：java.lang.Double
					Double val = (Double) m.invoke(object);
					if (val == null) {
						if (!(null == contexts[i] || "".equals(contexts[i]))) {
							result = false;
						}
					} else if ("".equals(contexts[i])) {
						result = false;
					} else if (val.compareTo(Double.parseDouble(contexts[i])) != 0) {
						result = false;
					}
					// 打印比较结果信息
					showCompareResultInfo(tableInfo, fieldTypeMap.get(cols[i]), cols[i], val, contexts[i], result);
				} else if ("java.lang.Boolean".equals(fieldTypeMap.get(cols[i]))) {
					// 类型为：java.lang.Boolean
					Boolean val = (Boolean) m.invoke(object);
					if (val == null) {
						if (!(null == contexts[i] || "".equals(contexts[i]))) {
							result = false;
						}
					} else if ("".equals(contexts[i])) {
						result = false;
					} else if (val.compareTo(Boolean.parseBoolean(contexts[i])) != 0) {
						result = false;
					}
					// 打印比较结果信息
					showCompareResultInfo(tableInfo, fieldTypeMap.get(cols[i]), cols[i], val, contexts[i], result);
				} else {
					// 其他数据类型记录异常信息
					Object val = m.invoke(object);
					showCompareResultInfo(tableInfo, fieldTypeMap.get(cols[i]), cols[i], val, contexts[i], result);
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
			String errorMsg = "比较" + DataTransferConstant.TABLES.get(tableInfo) + "文件内容出错";
			String remark = "比较" + DataTransferConstant.TABLES.get(tableInfo) + "文件内容出错，错误信息：" + e.getMessage();
			addErrorInfo(tableInfo, MonAlrmLvlEnum.SERIOUS.getEnname(), errorMsg, remark);
			logger.error(remark);
		}
		logger.info("校验******[" + tableInfo + "]******文件内容详细字段信息结束");
		return result;
	}

	/**
	 * 
	 * 获取对象信息 <br>
	 * 0.1:ludayong:2019年5月18日 下午12:43:09:新增 <br>
	 * 
	 * @author ludayong
	 * @since 2019年5月18日 下午12:43:09
	 * @date 2019年5月18日 下午12:43:09
	 * @version 0.1
	 */
	public Object setObjectValue(String tableInfo, Object object, String cols[], String[] contexts) {
		logger.info("设置******[" + tableInfo + "]******文件内容字段信息开始");
		boolean result = true;
		try {
			// 获取对象的字段类型返回Map
			Map<String, String> fieldTypeMap = DueDataUtil.getObjectFieldType(object);
			for (int i = 0; i < cols.length; i++) {
				// 文件内容已经读取完时退出
				if (i >= contexts.length) {
					break;
				}
				if ("java.lang.String".equals(fieldTypeMap.get(cols[i]))) {
					// 类型为：java.lang.String
					Method m = (Method) object.getClass().getMethod("set" + cols[i], String.class);
					m.invoke(object, contexts[i]);
				} else if ("java.math.BigDecimal".equals(fieldTypeMap.get(cols[i]))) {
					// 类型为：java.math.BigDecimal
					Method m = (Method) object.getClass().getMethod("set" + cols[i], BigDecimal.class);
					if (!StringUtil.isNullorBank(contexts[i])) {
						result = true;
						m.invoke(object, new BigDecimal(contexts[i]));
					} else {
						result = false;
					}
				} else if ("java.lang.Integer".equals(fieldTypeMap.get(cols[i]))) {
					// 类型为：java.lang.Integer
					Method m = (Method) object.getClass().getMethod("set" + cols[i], Integer.class);
					if (!StringUtil.isNullorBank(contexts[i])) {
						result = true;
						m.invoke(object, Integer.parseInt(contexts[i]));
					} else {
						result = false;
					}
				} else if ("java.lang.Double".equals(fieldTypeMap.get(cols[i]))) {
					// 类型为：java.lang.Double
					Method m = (Method) object.getClass().getMethod("set" + cols[i], Double.class);
					if (!StringUtil.isNullorBank(contexts[i])) {
						result = true;
						m.invoke(object, Double.parseDouble(contexts[i]));
					} else {
						result = false;
					}
				} else if ("java.lang.Boolean".equals(fieldTypeMap.get(cols[i]))) {
					// 类型为：java.lang.Boolean
					Method m = (Method) object.getClass().getMethod("set" + cols[i], Boolean.class);
					if (!StringUtil.isNullorBank(contexts[i])) {
						result = true;
						m.invoke(object, Boolean.parseBoolean(contexts[i]));
					} else {
						result = false;
					}
				} else {
					result = false;
				}
				// 打印设置值信息
				showSetObjectValueResultInfo(tableInfo, fieldTypeMap.get(cols[i]), cols[i], contexts[i], result);
			}
			logger.info("设置" + DataTransferConstant.TABLES.get(tableInfo) + "对象信息：" + JSONObject.toJSONString(object));
		} catch (Exception e) {
			e.printStackTrace();
			String errorMsg = "设置" + DataTransferConstant.TABLES.get(tableInfo) + "文件内容出错";
			String remark = "设置" + DataTransferConstant.TABLES.get(tableInfo) + "文件内容出错，错误信息：" + e.getMessage();
			addErrorInfo(tableInfo, MonAlrmLvlEnum.SERIOUS.getEnname(), errorMsg, remark);
			logger.error(remark);
		}
		logger.info("设置******[" + tableInfo + "]******文件内容字段信息结束");
		return object;
	}

	/**
	 * 
	 * 获取数据库列信息 <br>
	 * 0.1:ludayong:2019年5月18日 下午12:43:09:新增 <br>
	 * 
	 * @author ludayong
	 * @since 2019年5月18日 下午12:43:09
	 * @date 2019年5月18日 下午12:43:09
	 * @version 0.1
	 */
	public String[] getDataCols(String tableName, String tableDesc) {
		logger.info("获取******[" + tableDesc + "]******字段信息开始");
		// 数据库列信息
		String cols[] = new String[] {};
		try {
			switch (tableName) {
			case "s048_bd_sxapply":
				// "授信申请信息"
				cols = DataTransferConstant.BD_SXAPPLY_COLS;
				break;
			case "s048_bd_yxapply":
				// "用信申请信息"
				cols = DataTransferConstant.BD_YXAPPLY_COLS;
				break;
			case "s048_dw_baidu_open":
				// "贷款放款明细信息"
				cols = DataTransferConstant.DW_BAIDU_OPEN_COLS;
				break;
			case "s048_dw_baidu_loan":
				// "借据信息"
				cols = DataTransferConstant.DW_BAIDU_LOAN_COLS;
				break;
			case "s048_dw_baidu_repay_plan":
				// "借据分期计划信息"
				cols = DataTransferConstant.DW_BAIDU_REPAY_PLAN_COLS;
				break;
			case "s048_dw_baidu_repay":
				// "借据还款信息"
				cols = DataTransferConstant.DW_BAIDU_REPAY_COLS;
				break;
			case "s048_dw_baidu_repay_item":
				// "借据还款信息明细信息"
				cols = DataTransferConstant.DW_BAIDU_REPAY_ITEM_COLS;
				break;
			case "s048_dw_baidu_loan_rate":
				// "贷款利息费率信息"
				cols = DataTransferConstant.DW_BAIDU_LOAN_RATE_COLS;
				break;
			case "s048_dw_baidu_ledger":
				// "并账信息"
				cols = DataTransferConstant.DW_BAIDU_LEDGER_COLS;
				break;
			default:
			}
			logger.info(tableDesc + "列信息：" + JSONObject.toJSONString(cols));
		} catch (Exception e) {
			e.printStackTrace();
			String errorMsg = "获取" + tableDesc + "数据库列信息出错";
			String remark = "获取" + tableDesc + "数据库列信息出错，错误信息：" + e.getMessage();
			addErrorInfo(tableName, MonAlrmLvlEnum.SERIOUS.getEnname(), errorMsg, remark);
			logger.error(remark);
		}
		logger.info("获取******[" + tableDesc + "]******字段信息结束");
		return cols;
	}

	/***
	 * 
	 * 文件内容转对象信息 <br>
	 * 0.1:ludayong:2019年5月18日 下午3:57:09:新增 <br>
	 * 
	 * @author ludayong
	 * @since 2019年5月18日 下午3:57:09
	 * @date 2019年5月18日 下午3:57:09
	 * @version 0.1
	 */
	private Object getDataTransferInfo(String tableInfo, String[] contexts) {
		logger.info("获取******[" + tableInfo + "]******文件内容转对象信息开始");
		try {
			// 获取数据库列信息
			String cols[] = getDataCols(tableInfo, DataTransferConstant.TABLES.get(tableInfo));
			switch (tableInfo) {
			case "s048_bd_sxapply":
				// "授信申请信息"
				BdSxapplyTempVO bdSxapplyTempVO = new BdSxapplyTempVO();
				setObjectValue(tableInfo, bdSxapplyTempVO, cols, contexts);
				return bdSxapplyTempVO;
			case "s048_bd_yxapply":
				// "用信申请信息"
				BdYxapplyTempVO bdYxapplyTempVO = new BdYxapplyTempVO();
				setObjectValue(tableInfo, bdYxapplyTempVO, cols, contexts);
				return bdYxapplyTempVO;
			case "s048_dw_baidu_open":
				// "贷款放款明细信息"
				DwBaiduOpenTempVO dwBaiduOpenTempVO = new DwBaiduOpenTempVO();
				setObjectValue(tableInfo, dwBaiduOpenTempVO, cols, contexts);
				return dwBaiduOpenTempVO;
			case "s048_dw_baidu_loan":
				// "借据信息"
				DwBaiduLoanTempVO dwBaiduLoanTempVO = new DwBaiduLoanTempVO();
				setObjectValue(tableInfo, dwBaiduLoanTempVO, cols, contexts);
				return dwBaiduLoanTempVO;
			case "s048_dw_baidu_repay_plan":
				// "借据分期计划信息"
				DwBaiduRepayPlanTempVO dwBaiduRepayPlanTempVO = new DwBaiduRepayPlanTempVO();
				setObjectValue(tableInfo, dwBaiduRepayPlanTempVO, cols, contexts);
				return dwBaiduRepayPlanTempVO;
			case "s048_dw_baidu_repay":
				// "借据还款信息"
				DwBaiduRepayTempVO dwBaiduRepayTempVO = new DwBaiduRepayTempVO();
				setObjectValue(tableInfo, dwBaiduRepayTempVO, cols, contexts);
				return dwBaiduRepayTempVO;
			case "s048_dw_baidu_repay_item":
				// "借据还款信息明细信息"
				DwBaiduRepayItemTempVO dwBaiduRepayItemTempVO = new DwBaiduRepayItemTempVO();
				setObjectValue(tableInfo, dwBaiduRepayItemTempVO, cols, contexts);
				return dwBaiduRepayItemTempVO;
			case "s048_dw_baidu_loan_rate":
				// "贷款利息费率信息"
				DwBaiduLoanRateTempVO dwBaiduLoanRateTempVO = new DwBaiduLoanRateTempVO();
				setObjectValue(tableInfo, dwBaiduLoanRateTempVO, cols, contexts);
				return dwBaiduLoanRateTempVO;
			case "s048_dw_baidu_ledger":
				// "并账信息"
				DwBaiduLedgerTempVO dwBaiduLedgerTempVO = new DwBaiduLedgerTempVO();
				setObjectValue(tableInfo, dwBaiduLedgerTempVO, cols, contexts);
				return dwBaiduLedgerTempVO;
			default:
				return null;
			}
		} catch (Exception e) {
			e.printStackTrace();
			String errorMsg = DataTransferConstant.TABLES.get(tableInfo) + "内容校验出错";
			String remark = DataTransferConstant.TABLES.get(tableInfo) + "内容校验出错，错误信息：" + e.getMessage();
			addErrorInfo(tableInfo, MonAlrmLvlEnum.SERIOUS.getEnname(), errorMsg, remark);
			logger.error(remark);
			return null;
		} finally {
			logger.info("获取******[" + tableInfo + "]******文件内容转对象信息结束");
		}
	}

	/**
	 * 
	 * 打印数据迁移内容校验信息 <br>
	 * 0.1:ludayong:2019年5月18日 下午4:52:29:新增<br>
	 * 
	 * @author ludayong
	 * @since 2019年5月18日 下午4:52:29
	 * @date 2019年5月18日 下午4:52:29
	 * @version 0.1
	 */
	private void showCompareResultInfo(String tableInfo, String fieldType, String fieldName, Object cloVal, String contextVal,
			boolean result) {
		String remark = "字段类型Type：[" + fieldType + "]******，字段名称Name：[" + fieldName + "]，数据库字段值******Value：[" + cloVal
				+ "]，迁移文件字段值******Value：[" + contextVal + "]******，比较结果[" + result + "]";
		if (result) {
			logger.info(remark);
		} else {
			addErrorInfo(tableInfo, MonAlrmLvlEnum.SERIOUS.getEnname(), remark, remark);
			logger.info(remark);
		}
	}

	/**
	 * 
	 * 打印数据迁移内容校验信息 <br>
	 * 0.1:ludayong:2019年5月18日 下午4:52:29:新增<br>
	 * 
	 * @author ludayong
	 * @since 2019年5月18日 下午4:52:29
	 * @date 2019年5月18日 下午4:52:29
	 * @version 0.1
	 */
	private void showSetObjectValueResultInfo(String tableInfo, String fieldType, String fieldName, String contextVal, boolean result) {
		String remark = "字段类型Type：[" + fieldType + "]******，字段名称Name：[" + fieldName + "]，迁移文件字段值******Value：[" + contextVal
				+ "]******，赋值结果[" + result + "]";
		if (result) {
			logger.info(remark);
		} else {
			addErrorInfo(tableInfo, MonAlrmLvlEnum.SERIOUS.getEnname(), remark, remark);
			logger.info(remark);
		}
	}

	/**
	 * 
	 * 记录异常信息 <br>
	 * 0.1:ludayong:2019年5月7日 上午11:31:23:新增 <br>
	 * 
	 * @author ludayong
	 * @since 2019年5月7日 上午11:31:23
	 * @date 2019年5月7日 上午11:31:23
	 * @version 0.1
	 */
	private void addErrorInfo(String tableName, String errorType, String errorMsg, String remark) {
		AccoutErroTempVO accoutErroTempVO = new AccoutErroTempVO();
		// 表名
		accoutErroTempVO.setTableName(tableName);
		// 错误级别
		accoutErroTempVO.setErroType(errorType);
		// 错误信息
		accoutErroTempVO.setErroMsg(errorMsg);
		// 备注
		accoutErroTempVO.setRemark(remark);
		// 创建时间
		accoutErroTempVO.setCreateData(DateTool.getCurrentDateTime());
		// 修改时间
		accoutErroTempVO.setLastModifyTime(DateTool.getCurrentDateTime());
		// 记录异常信息
		accoutErroTempService.insert(accoutErroTempVO);
	}
}
